home *** CD-ROM | disk | FTP | other *** search
/ Visual Cafe 3 / Visual Cafe 3.ISO / Vcafe / Main.bin / ByteArrayOutputStream.java < prev    next >
Text File  |  1998-09-22  |  6KB  |  190 lines
  1. /*
  2.  * @(#)ByteArrayOutputStream.java    1.24 98/07/01
  3.  *
  4.  * Copyright 1995-1998 by Sun Microsystems, Inc.,
  5.  * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
  6.  * All rights reserved.
  7.  * 
  8.  * This software is the confidential and proprietary information
  9.  * of Sun Microsystems, Inc. ("Confidential Information").  You
  10.  * shall not disclose such Confidential Information and shall use
  11.  * it only in accordance with the terms of the license agreement
  12.  * you entered into with Sun.
  13.  */
  14.  
  15. package java.io;
  16.  
  17.  
  18. /**
  19.  * This class implements an output stream in which the data is 
  20.  * written into a byte array. The buffer automatically grows as data 
  21.  * is written to it. 
  22.  * The data can be retrieved using <code>toByteArray()</code> and
  23.  * <code>toString()</code>.
  24.  *
  25.  * @author  Arthur van Hoff
  26.  * @version 1.24, 07/01/98
  27.  * @since   JDK1.0
  28.  */
  29.  
  30. public class ByteArrayOutputStream extends OutputStream {
  31.  
  32.     /** 
  33.      * The buffer where data is stored. 
  34.      */
  35.     protected byte buf[];
  36.  
  37.     /**
  38.      * The number of valid bytes in the buffer. 
  39.      */
  40.     protected int count;
  41.  
  42.     /**
  43.      * Creates a new byte array output stream. The buffer capacity is 
  44.      * initially 32 bytes, though its size increases if necessary. 
  45.      */
  46.     public ByteArrayOutputStream() {
  47.     this(32);
  48.     }
  49.  
  50.     /**
  51.      * Creates a new byte array output stream, with a buffer capacity of 
  52.      * the specified size, in bytes. 
  53.      *
  54.      * @param   size   the initial size.
  55.      */
  56.     public ByteArrayOutputStream(int size) {
  57.     buf = new byte[size];
  58.     }
  59.  
  60.     /**
  61.      * Writes the specified byte to this byte array output stream. 
  62.      *
  63.      * @param   b   the byte to be written.
  64.      */
  65.     public synchronized void write(int b) {
  66.     int newcount = count + 1;
  67.     if (newcount > buf.length) {
  68.         byte newbuf[] = new byte[Math.max(buf.length << 1, newcount)];
  69.         System.arraycopy(buf, 0, newbuf, 0, count);
  70.         buf = newbuf;
  71.     }
  72.     buf[count] = (byte)b;
  73.     count = newcount;
  74.     }
  75.  
  76.     /**
  77.      * Writes <code>len</code> bytes from the specified byte array 
  78.      * starting at offset <code>off</code> to this byte array output stream.
  79.      *
  80.      * @param   b     the data.
  81.      * @param   off   the start offset in the data.
  82.      * @param   len   the number of bytes to write.
  83.      */
  84.     public synchronized void write(byte b[], int off, int len) {
  85.     int newcount = count + len;
  86.     if (newcount > buf.length) {
  87.         byte newbuf[] = new byte[Math.max(buf.length << 1, newcount)];
  88.         System.arraycopy(buf, 0, newbuf, 0, count);
  89.         buf = newbuf;
  90.     }
  91.     System.arraycopy(b, off, buf, count, len);
  92.     count = newcount;
  93.     }
  94.  
  95.     /**
  96.      * Writes the complete contents of this byte array output stream to 
  97.      * the specified output stream argument, as if by calling the output 
  98.      * stream's write method using <code>out.write(buf, 0, count)</code>.
  99.      *
  100.      * @param      out   the output stream to which to write the data.
  101.      * @exception  IOException  if an I/O error occurs.
  102.      */
  103.     public synchronized void writeTo(OutputStream out) throws IOException {
  104.     out.write(buf, 0, count);
  105.     }
  106.  
  107.     /**
  108.      * Resets the <code>count</code> field of this byte array output 
  109.      * stream to zero, so that all currently accumulated output in the 
  110.      * ouput stream is discarded. The output stream can be used again, 
  111.      * reusing the already allocated buffer space. 
  112.      *
  113.      * @see     java.io.ByteArrayInputStream#count
  114.      */
  115.     public synchronized void reset() {
  116.     count = 0;
  117.     }
  118.  
  119.     /**
  120.      * Creates a newly allocated byte array. Its size is the current 
  121.      * size of this output stream and the valid contents of the buffer 
  122.      * have been copied into it. 
  123.      *
  124.      * @return  the current contents of this output stream, as a byte array.
  125.      * @see     java.io.ByteArrayOutputStream#size()
  126.      */
  127.     public synchronized byte toByteArray()[] {
  128.     byte newbuf[] = new byte[count];
  129.     System.arraycopy(buf, 0, newbuf, 0, count);
  130.     return newbuf;
  131.     }
  132.  
  133.     /**
  134.      * Returns the current size of the buffer.
  135.      *
  136.      * @return  the value of the <code>count</code> field, which is the number
  137.      *          of valid bytes in this output stream.
  138.      * @see     java.io.ByteArrayOutputStream#count
  139.      */
  140.     public int size() {
  141.     return count;
  142.     }
  143.  
  144.     /**
  145.      * Converts the buffer's contents into a string, translating bytes into
  146.      * characters according to the platform's default character encoding.
  147.      */
  148.     public String toString() {
  149.     return new String(buf, 0, count);
  150.     }
  151.  
  152.     /**
  153.      * Converts the buffer's contents into a string, translating bytes into
  154.      * characters according to the specified character encoding.
  155.      *
  156.      * @param   enc  a character-encoding name.
  157.      * @since   JDK1.1
  158.      */
  159.     public String toString(String enc) throws UnsupportedEncodingException {
  160.     return new String(buf, 0, count, enc);
  161.     }
  162.  
  163.     /**
  164.      * Creates a newly allocated string. Its size is the current size of 
  165.      * the output stream and the valid contents of the buffer have been 
  166.      * copied into it. Each character <i>c</i> in the resulting string is 
  167.      * constructed from the corresponding element <i>b</i> in the byte 
  168.      * array such that:
  169.      * <ul><code>
  170.      *     c == (char)(((hibyte & 0xff) << 8) | (b & 0xff))
  171.      * </code></ul>
  172.      *
  173.      * @deprecated This method does not properly convert bytes into characters.
  174.      * As of JDK 1.1, the preferred way to do this is via the
  175.      * <code>toString(String enc)</code> method, which takes an encoding-name
  176.      * argument, or the <code>toString()</code> method, which uses the
  177.      * platform's default character encoding.
  178.      *
  179.      * @param      hibyte    the high byte of each resulting Unicode character.
  180.      * @return     the current contents of the output stream, as a string.
  181.      * @see        java.io.ByteArrayOutputStream#size()
  182.      * @see        java.io.ByteArrayOutputStream#toString(String)
  183.      * @see        java.io.ByteArrayOutputStream#toString()
  184.      */
  185.     public String toString(int hibyte) {
  186.     return new String(buf, hibyte, 0, count);
  187.     }
  188.  
  189. }
  190.